const CommonUtil = {
    /**
     * 敏感信息加密隐藏
     * @param {String} str 被处理字符串
     * @param {Number} frontLen 词首可显示的长度
     * @param {Number} endLen 词尾可显示的长度
     * @returns 加密字符串
     */
    hideCode(str, frontLen, endLen) {
        var tmp = str;
        if (tmp == null)
            tmp = "";
        var len = tmp.length - frontLen - endLen;
        var xing = '';
        for (var i = 0; i < len; i++) {
            xing += '*';
        }
        return tmp.substring(0, frontLen) + xing + tmp.substring(tmp.length - endLen);
    },
    /**
     * 表单数据处理
     * @param {number} pd 模糊查询拼接判断 0为 + 'like' ; 1为'fuzzy'+
     * @param {Object} formData 表单原始Object数据
     * @param {Number} page 页数
     * @param {Number} pageSize 每页条数
     */
    // 表单传参处理
    paramsFun(pd,formData,key,page=1,pageSize=10){
        let f1= {}
        for(let key in formData){
            if(!formData[key].hasOwnProperty('isSave')){
                let a = ''
                if(formData[key].oValue){
                    if(pd==0){
                        if(key=='accNums'){
                            a = 'accNumLike'
                        }else{
                            a = key+'Like';
                        }
                    }else if(pd==1){
                        let newKey = key.slice(0,1).toUpperCase()+key.slice(1);
                        a = 'fuzzy'+ newKey;
                    }
                }else{
                    a = key;
                }
                f1[a]=formData[key].cValue.trim();
            }
        }
        f1.pageInfo={};
        f1.pageInfo[key]=page;
        f1.pageInfo.pageSize=pageSize;
        return f1
    },

    /**
     * 表单数据处理不带模糊精确查询
     * @param {Object} formData 表单原始Object数据
     */
    // 表单传参处理
    paramsFun2(formData){
        let f1= {}
        for(let key in formData){
            if(formData[key].type=='checkbox'){
                if(formData[key].cValue){
                    f1[key]=1;
                }else{
                    f1[key]=0;
                }
            }else{
                f1[key]=formData[key].cValue
            }
        }
        return f1
    },
    /**
     * 客户定位表单初始化默认值
     * @param {Object} formData 表单原始Object数据
     */
    formInit(form){
        for(var key in form){
            form[key].cValue = '';
            if(form[key].hasOwnProperty('oValue')){
                form[key].oValue = form[key].opt[0].value;
            }
        }
        return form
    },
    /**
     * 随机生成六位不重复字符串
     */
    refreshCode() {
        let code = '0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM',//62个字符 随机选择4位
            result = '';
        for (let i = 0; i < 6; i++) {
            //随机选择一位  （0,61） 写出0到61的随机的索引数字
            let code_index = Math.round(Math.random()*61);
            //得到随机的索引  取出随机地字符
            let char = code[code_index];
            //随机取出的字符 存在几个相同重复的问题 ，而且对于字母，不能区分大小写。
            // 避免重复的思路是：取出字符之后,和最后的result对比一下，看看里边是不是已经存在了，如果存在本次循环就终止，进行下一次
            if (result.toUpperCase().indexOf(char.toUpperCase()) > -1)
                //indexOf() == -1 说明结果里边没有要找的字符 那么 > -1 就是 里边有重复的字符
            {
                i --;
                //为什么会 --？ 因为如果条件成立，那么本轮循环就结束进行下一轮循环（自然i就加1了），那么本轮本应该取出的字符就没有了
                //到最后会少一个字符 缺席
                continue;//终止本轮循环 进行下一轮
            }
            result += char;
        }
        return result
    },

    /**
     * 加法运算，避免数据相加小数点后产生多位数和计算精度损失。
     *
     * @param 多个小数相加
     */
      numAdd(arr) {
        let bastNumArr = [],adds = null;
        arr.forEach(item=>{
            let baseNum = null;
            try {
                baseNum = item.toString().split(".")[1].length;
            } catch (e) {
                baseNum = 0;
            }
            baseNum = Math.pow(10, baseNum);
            bastNumArr.push(baseNum);
        })
        bastNumArr.sort(function (a,b) {return a<b?1:-1});
        arr.forEach(item=>{
            let max = bastNumArr[0];
            if(max == 0){
                adds += item;
            }else{
                adds =  (adds * max + item * max) / max;
            }

        });
        return adds
     },
    /**
     * 减法运算，避免数据相减小数点后产生多位数和计算精度损失。
     *
     * @param num1被减数  |  num2减数
     */
    numSub(num1, num2) {
        var baseNum, baseNum1, baseNum2;
        var precision;// 精度
        try {
            baseNum1 = num1.toString().split(".")[1].length;
        } catch (e) {
            baseNum1 = 0;
        }
        try {
            baseNum2 = num2.toString().split(".")[1].length;
        } catch (e) {
            baseNum2 = 0;
        }
        baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
        precision = (baseNum1 >= baseNum2) ? baseNum1 : baseNum2;
        return ((num1 * baseNum - num2 * baseNum) / baseNum).toFixed(precision);
    },
    /**
     * 乘法运算，避免数据相乘小数点后产生多位数和计算精度损失。
     *
     * @param num1被乘数 | num2乘数
     */
    numMulti(num1, num2) {
        var baseNum = 0;
        try {
            baseNum += num1.toString().split(".")[1].length;
        } catch (e) {
        }
        try {
            baseNum += num2.toString().split(".")[1].length;
        } catch (e) {
        }
        return Number(num1.toString().replace(".", "")) * Number(num2.toString().replace(".", "")) / Math.pow(10, baseNum);
    },

    isFileExist(filePath) {//检验模块中JS是否存在
        debugger
        try {
          var isfile = _import(filePath);
          return true;
        } catch (e) {
          if (filePath == "Layout") {
            return true;
          }
          return false;
        }
      },
    /**
     * 驼峰转大写
     * **/
    toCapital: (name)=>{
        var tfname = '';
        var array = name.split('');
        for(var i=0;i<array.length;i++){
            if(i==array.length-1) {tfname=name;break}
            let v = array[i],
                v2 = array[i+1];
            if(/^[a-z]+$/.test(v)){
                if(/^[a-z]+$/.test(v2)){
                    tfname = name.replace(/([A-Z])/g,"_$1").toUpperCase();
                    break;
                }
            }
        };
        return tfname
    },
    /**
     * 大写下划线转驼峰
     */
    toHump: (name) => {
        var tfname = '';
        var array = name.split('');
        for(var i=0;i<array.length;i++){
            if(i==array.length-1) {tfname=name;break}
            let v = array[i],
                v2 = array[i+1];
            if(/^[A-Z]+$/.test(v)){
                if(/^[A-Z]+$/.test(v2)){
                    let n = name.toLowerCase(name);
                    tfname =  n.replace(/_(\w)/g, function(all, letter){
                        return letter.toUpperCase();
                    });
                    break;
                }
            }
        };
        return tfname
    }
}

export default CommonUtil;
